home *** CD-ROM | disk | FTP | other *** search
/ TeX 1995 July / TeX CD-ROM July 1995 (Disc 1)(Walnut Creek)(1995).ISO / graphics / gnuplot / term / dumb.trm < prev    next >
Text File  |  1993-09-15  |  6KB  |  307 lines
  1. /*
  2.  * $Id: dumb.trm%v 3.50 1993/07/09 05:35:24 woo Exp $
  3.  *
  4.  */
  5.  
  6. /* GNUPLOT - dumb.trm */
  7. /*
  8.  * Copyright (C) 1991, 1992
  9.  *
  10.  * Permission to use, copy, and distribute this software and its
  11.  * documentation for any purpose with or without fee is hereby granted,
  12.  * provided that the above copyright notice appear in all copies and
  13.  * that both that copyright notice and this permission notice appear
  14.  * in supporting documentation.
  15.  *
  16.  * Permission to modify the software is granted, but not the right to
  17.  * distribute the modified code.  Modifications are to be distributed
  18.  * as patches to released version.
  19.  *
  20.  * This software  is provided "as is" without express or implied warranty.
  21.  *
  22.  * This file is included by ../term.c.
  23.  *
  24.  * This terminal driver supports:
  25.  *   DUMB terminals
  26.  *
  27.  * AUTHORS
  28.  *   Francois Pinard, 91-04-03
  29.  *           INTERNET: pinard@iro.umontreal.ca
  30.  *
  31.  * send your comments or suggestions to (info-gnuplot@dartmouth.edu).
  32.  *
  33.  */
  34.  
  35. #define DUMB_AXIS_CONST '\1'
  36. #define DUMB_BORDER_CONST '\2'
  37.  
  38. #define DUMB_XMAX 79
  39. #define DUMB_YMAX 24
  40.  
  41. static char *dumb_matrix = NULL;      /* matrix of characters */
  42. static char *dumb_priority = NULL;    /* matrix of priority at each position */
  43. static char dumb_pen;                 /* current character used to draw */
  44. static int dumb_x;                    /* current X position */
  45. static int dumb_y;                    /* current Y position */
  46. static int dumb_xmax = DUMB_XMAX;
  47. static int dumb_ymax = DUMB_YMAX;
  48.  
  49. #define DUMB_PIXEL(x,y) dumb_matrix[dumb_xmax*(y)+(x)]
  50.  
  51.  
  52. dumb_set_pixel(x,y,v,p)
  53. int x,y,v,p;
  54. {
  55.   if (p > dumb_priority[dumb_xmax*y+x])
  56.     {
  57.       dumb_matrix[dumb_xmax*y+x] = v;
  58.       dumb_priority[dumb_xmax*y+x] = p;
  59.     }
  60. }
  61.  
  62.  
  63. DUMB_options()
  64. {
  65.   int x,y;
  66.   struct value a;
  67.   extern struct value *const_express();
  68.   extern double real();
  69.  
  70.   if (!END_OF_COMMAND) {
  71.     x = (int) real(const_express(&a));
  72.     if (!END_OF_COMMAND) {
  73.       y = (int) real(const_express(&a));
  74.       dumb_xmax = term_tbl[term].xmax = x;
  75.       dumb_ymax = term_tbl[term].ymax = y;
  76.     }
  77.   }
  78.  
  79.   sprintf(term_options, "%d %d",dumb_xmax,dumb_ymax);
  80. }
  81.  
  82.  
  83. DUMB_init()
  84. {
  85.   if (dumb_matrix)
  86.     free(dumb_matrix);
  87.  
  88.   dumb_matrix = alloc ((unsigned long)dumb_xmax * dumb_ymax * 2, "dumb terminal");
  89.  
  90.   dumb_priority = dumb_matrix + dumb_xmax * dumb_ymax;
  91. }
  92.  
  93.  
  94. char *
  95. DUMB_str_state()
  96. {
  97.    static char str[80];
  98.  
  99.    sprintf( str, "%d %d", dumb_xmax, dumb_ymax );
  100.  
  101.    return str;
  102. }
  103.  
  104.  
  105. DUMB_graphics ()
  106. {
  107.   int i;
  108.   char *pm = dumb_matrix, *pp = dumb_priority;
  109.  
  110.   for ( i = dumb_xmax * dumb_ymax; i > 0; i-- ) {
  111.     *pm++ = ' ';
  112.     *pp++ = 0;
  113.   }
  114. }
  115.  
  116.  
  117. DUMB_text ()
  118. {
  119.   int x, y, l;
  120.  
  121.   putc ('\f', outfile);
  122.   for (y = dumb_ymax - 1; y >= 0; y--)
  123.     {
  124.       for (l = dumb_xmax; l > 0 && DUMB_PIXEL (l - 1, y) == ' '; l--)
  125.        ;
  126.       for (x = 0; x < l; x++)
  127.        putc (DUMB_PIXEL (x, y), outfile);
  128.       if (y > 0)
  129.        putc ('\n', outfile);
  130.     }
  131.   fflush (outfile);
  132. }
  133.  
  134.  
  135. DUMB_reset()
  136. {
  137.   free (dumb_matrix);
  138.   dumb_matrix = NULL;
  139. }
  140.  
  141.  
  142. DUMB_linetype(linetype)
  143. int linetype;
  144. {
  145.   static char pen_type[7] = {'*', '#', '$', '%', '@', '&', '='};
  146.  
  147.   if (linetype == -2)
  148.     dumb_pen = DUMB_BORDER_CONST;
  149.   else if (linetype == -1)
  150.     dumb_pen = DUMB_AXIS_CONST;
  151.   else
  152.     {
  153.       linetype = linetype % 7;
  154.       dumb_pen = pen_type[linetype];
  155.     }
  156. }
  157.  
  158.  
  159. DUMB_move(x, y)
  160. int x, y;
  161. {
  162.   dumb_x = x;
  163.   dumb_y = y;
  164. }
  165.  
  166.  
  167. DUMB_point(x,y,point)
  168. int x,y,point;
  169. {
  170.   dumb_set_pixel (x, y, point == -1 ? '.' : point % 26 + 'A', 4);
  171. }
  172.  
  173.  
  174. DUMB_vector(x,y)
  175. int x,y;
  176. {
  177.   char pen, pen1;
  178.   int priority;
  179.   int delta;
  180.  
  181.   if (abs (y - dumb_y) > abs (x - dumb_x))
  182.     {
  183.       switch (dumb_pen)
  184.        {
  185.        case DUMB_AXIS_CONST:
  186.          pen = ':';
  187.          pen1 = '+';
  188.          priority = 1;
  189.          break;
  190.  
  191.        case DUMB_BORDER_CONST:
  192.          pen = '|';
  193.          pen1 = '+';
  194.          priority = 2;
  195.          break;
  196.  
  197.        default:
  198.          pen = dumb_pen;
  199.          pen1 = dumb_pen;
  200.          priority = 3;
  201.          break;
  202.        }
  203.       dumb_set_pixel (dumb_x, dumb_y, pen1, priority);
  204.       for (delta = 1; delta < abs (y - dumb_y); delta++)
  205.        dumb_set_pixel (dumb_x
  206.                        + (int) ((double) (x - dumb_x) * delta / abs(y - dumb_y)
  207.                                 + 0.5),
  208.                        dumb_y + delta * sign (y - dumb_y),
  209.                        pen, priority);
  210.       dumb_set_pixel (x, y, pen1, priority);
  211.     }
  212.   else if (abs (x - dumb_x) > abs (y - dumb_y))
  213.     {
  214.       switch (dumb_pen)
  215.        {
  216.        case DUMB_AXIS_CONST:
  217.          pen = '.';
  218.          pen1 = '+';
  219.          priority = 1;
  220.          break;
  221.  
  222.        case DUMB_BORDER_CONST:
  223.          pen = '-';
  224.          pen1 = '+';
  225.          priority = 2;
  226.          break;
  227.  
  228.        default:
  229.          pen = dumb_pen;
  230.          pen1 = dumb_pen;
  231.          priority = 3;
  232.          break;
  233.        }
  234.       dumb_set_pixel (dumb_x, dumb_y, pen1, priority);
  235.       for (delta = 1; delta < abs (x - dumb_x); delta++)
  236.        dumb_set_pixel (dumb_x + delta * sign (x - dumb_x),
  237.                        dumb_y +
  238.                        (int) ((double) (y - dumb_y) * delta / abs(x - dumb_x)
  239.                               + 0.5),
  240.                        pen, priority);
  241.       dumb_set_pixel (x, y, pen1, priority);
  242.     }
  243.   else
  244.     {
  245.       switch (dumb_pen)
  246.        {
  247.        case DUMB_AXIS_CONST:    /* zero length axis */
  248.          pen = '+';
  249.          priority = 1;
  250.          break;
  251.  
  252.        case DUMB_BORDER_CONST:    /* zero length border */
  253.          pen = '+';
  254.          priority = 2;
  255.          break;
  256.  
  257.        default:
  258.          pen = dumb_pen;
  259.          priority = 3;
  260.          break;
  261.        }
  262.       for (delta = 0; delta <= abs (x - dumb_x); delta++)
  263.     dumb_set_pixel (dumb_x + delta * sign (x - dumb_x),
  264.             dumb_y + delta * sign (y - dumb_y),
  265.             pen, priority);
  266.     }
  267.   dumb_x = x;
  268.   dumb_y = y;
  269. }
  270.  
  271.  
  272. DUMB_put_text(x,y,str)
  273. int x, y;
  274. char *str;
  275. {
  276.   int length;
  277.  
  278.   length = strlen(str);
  279.   if (x + length > dumb_xmax)
  280.     x = max (0, dumb_xmax - length);
  281.  
  282.   for (; x < dumb_xmax && *str; x++, str++)
  283.     dumb_set_pixel (x, y, *str, 5);
  284. }
  285.  
  286.  
  287. DUMB_arrow (sx,sy,ex,ey)
  288. int sx,sy,ex,ey;
  289. {
  290.   char saved_pen;
  291.   char saved_x;
  292.   char saved_y;
  293.  
  294.   saved_pen = dumb_pen;
  295.   saved_x = dumb_x;
  296.   saved_y = dumb_y;
  297.  
  298.   dumb_pen = '>';
  299.   dumb_x = sx;
  300.   dumb_y = sy;
  301.   DUMB_vector (ex,ey);
  302.  
  303.   dumb_pen = saved_pen;
  304.   dumb_x = saved_x;
  305.   dumb_y = saved_y;
  306. }
  307.